// Copyright 2018 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_COMPILER_MACHINE_GRAPH_H_
#define V8_COMPILER_MACHINE_GRAPH_H_

#include "src/base/compiler-specific.h"
#include "src/compiler/common-node-cache.h"
#include "src/compiler/common-operator.h"
#include "src/compiler/graph.h"
#include "src/compiler/machine-operator.h"
#include "src/globals.h"
#include "src/runtime/runtime.h"

namespace v8 {
namespace internal {
    namespace compiler {

        // Implements a facade on a Graph, enhancing the graph with machine-specific
        // notions, including a builder for common and machine operators, as well
        // as caching primitive constants.
        class V8_EXPORT_PRIVATE MachineGraph : public NON_EXPORTED_BASE(ZoneObject) {
        public:
            MachineGraph(Graph* graph, CommonOperatorBuilder* common,
                MachineOperatorBuilder* machine)
                : graph_(graph)
                , common_(common)
                , machine_(machine)
                , cache_(zone())
            {
            }

            // Creates a Int32Constant node, usually canonicalized.
            Node* Int32Constant(int32_t value);
            Node* Uint32Constant(uint32_t value)
            {
                return Int32Constant(bit_cast<int32_t>(value));
            }

            // Creates a Int64Constant node, usually canonicalized.
            Node* Int64Constant(int64_t value);
            Node* Uint64Constant(uint64_t value)
            {
                return Int64Constant(bit_cast<int64_t>(value));
            }

            // Creates a Int32Constant/Int64Constant node, depending on the word size of
            // the target machine.
            // TODO(turbofan): Code using Int32Constant/Int64Constant to store pointer
            // constants is probably not serializable.
            Node* IntPtrConstant(intptr_t value);

            Node* RelocatableInt32Constant(int32_t value, RelocInfo::Mode rmode);
            Node* RelocatableInt64Constant(int64_t value, RelocInfo::Mode rmode);
            Node* RelocatableIntPtrConstant(intptr_t value, RelocInfo::Mode rmode);

            // Creates a Float32Constant node, usually canonicalized.
            Node* Float32Constant(float value);

            // Creates a Float64Constant node, usually canonicalized.
            Node* Float64Constant(double value);

            // Creates a PointerConstant node.
            Node* PointerConstant(intptr_t value);
            template <typename T>
            Node* PointerConstant(T* value)
            {
                return PointerConstant(bit_cast<intptr_t>(value));
            }

            // Creates an ExternalConstant node, usually canonicalized.
            Node* ExternalConstant(ExternalReference ref);
            Node* ExternalConstant(Runtime::FunctionId function_id);

            // Global cache of the dead node.
            Node* Dead()
            {
                return Dead_ ? Dead_ : Dead_ = graph_->NewNode(common_->Dead());
            }

            CommonOperatorBuilder* common() const { return common_; }
            MachineOperatorBuilder* machine() const { return machine_; }
            Graph* graph() const { return graph_; }
            Zone* zone() const { return graph()->zone(); }

        protected:
            Graph* graph_;
            CommonOperatorBuilder* common_;
            MachineOperatorBuilder* machine_;
            CommonNodeCache cache_;
            Node* Dead_ = nullptr;

            DISALLOW_COPY_AND_ASSIGN(MachineGraph);
        };

    } // namespace compiler
} // namespace internal
} // namespace v8

#endif // V8_COMPILER_MACHINE_GRAPH_H_
